package com.ruoyi.training.service.impl;

import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.*;
import java.util.stream.Collectors;

import com.ruoyi.common.core.utils.DateUtils;
import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.common.security.utils.SecurityUtils;
import com.ruoyi.training.domain.Remarks;
import com.ruoyi.training.dto.*;
import com.ruoyi.training.domain.Registration;
import com.ruoyi.training.domain.Students;
import com.ruoyi.training.mapper.RegistrationMapper;
import com.ruoyi.training.mapper.StudentsMapper;
import com.ruoyi.training.service.IRemarksService;
import com.ruoyi.training.util.xuehua.SnowflakeIdUtils;
import com.ruoyi.training.vo.RecordsUploadProcessVo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.training.mapper.RecordsMapper;
import com.ruoyi.training.domain.Records;
import com.ruoyi.training.service.IRecordsService;

/**
 * 档案Service业务层处理
 *
 * @author ruoyi
 * @date 2025-09-18
 */
@Service
public class RecordsServiceImpl implements IRecordsService {

    // 定义所有档案类型的中英文映射（英文为数据库存储值，中文为展示值）
    private static final Map<String, String> RECORD_TYPE_MAP = new HashMap<String, String>() {{
        put("idFront", "身份证（正面）");
        put("idBack", "身份证（反面）");
        put("photo", "证件照");
        put("application", "申请表");
        put("education", "学历证明");
        put("medical", "体检报告");
    }};

    private static final Logger log = LoggerFactory.getLogger(RecordsServiceImpl.class);

    private static final SnowflakeIdUtils snowflake = new SnowflakeIdUtils(5, 8);

    @Autowired
    private RecordsMapper recordsMapper;

    @Autowired
    private RegistrationMapper registrationMapper;

    @Autowired
    private StudentsMapper studentsMapper;

    @Autowired
    private IRemarksService remarksService;

    // 从配置文件注入服务器URL和根路径（无需RecordsMapper，因为不操作数据库）
//    @Value("${server.url}")
//    private String serverUrl;
//
//    @Value("${file.upload.root-path}")
//    private String rootUploadPath;

    /**
     * 查询档案
     *
     * @param recordId 档案主键
     * @return 档案
     */
    @Override
    public Records selectRecordsByRecordId(String recordId) {
        return recordsMapper.selectRecordsByRecordId(recordId);
    }

    /**
     * 查询档案列表
     *
     * @param records 档案
     * @return 档案
     */
    @Override
    public List<Records> selectRecordsList(Records records) {
        return recordsMapper.selectRecordsList(records);
    }

    /**
     * 通过报名id查询档案列表
     * lqx
     */
    @Override
    public List<Records> selectRecordsByRegistrationId(String registrationId) {
        return recordsMapper.selectRecordsByRegistrationId(registrationId);
    }

    /**
     * 新增档案
     *
     * @param records 档案
     * @return 结果
     */
    @Override
    public int insertRecords(Records records) {
        records.setCreateTime(DateUtils.getNowDate());
        return recordsMapper.insertRecords(records);
    }

    /**
     * 修改档案
     *
     * @param records 档案
     * @return 结果
     */
    @Override
    public int updateRecords(Records records) {
        records.setUpdateTime(DateUtils.getNowDate());
        return recordsMapper.updateRecords(records);
    }

    /**
     * 批量删除档案
     *
     * @param recordIds 需要删除的档案主键
     * @return 结果
     */
    @Override
    public int deleteRecordsByRecordIds(String[] recordIds) {
        return recordsMapper.deleteRecordsByRecordIds(recordIds);
    }

    /**
     * 删除档案信息
     *
     * @param recordId 档案主键
     * @return 结果
     */
    @Override
    public int deleteRecordsByRecordId(String recordId) {
        return recordsMapper.deleteRecordsByRecordId(recordId);
    }

    /**
     * 通过报名id获取档案详细信息进行补充上传
     * lqx
     */
    @Override
    public List<RecordsUploadSupplementDto> selectRecordsByRegistrationIds(String[] registrationIds) {
        //创建list来存储查询出来的数据
        List<RecordsUploadSupplementDto> recordsUploadSupplementDtos = new ArrayList<>();
        //1.通过报名id来查询数据并处理
        for (String registrationId : registrationIds) {
            //创建对象存储数据
            RecordsUploadSupplementDto recordsUploadSupplementDto = new RecordsUploadSupplementDto();
            //存储报名id
            recordsUploadSupplementDto.setRegistrationId(registrationId);
            //通过报名id查询出学员id
            Registration registration = registrationMapper.selectRegistrationByRegistrationId(registrationId);
            //通过学员id查询用户信息
            Students students = studentsMapper.selectStudentsByStudentId(registration.getStudentId());
            //存储学员姓名
            recordsUploadSupplementDto.setStudentName(students.getStudentName());
            //通过报名id查询档案信息
            List<Records> records = recordsMapper.selectRecordsByRegistrationId(registrationId);
            //将方案信息中的url存入recordsUploadSupplementDto的recordsList中
            //收集所有 list 到集合
            List<Records> recordsList = new ArrayList<>();
            for (Records record : records) {
                recordsList.add(record);
            }
            //转换为数组并设置到 Dto 中
            recordsUploadSupplementDto.setRecordsList(recordsList);

            //将对象存储进list中
            recordsUploadSupplementDtos.add(recordsUploadSupplementDto);
        }
        return recordsUploadSupplementDtos;
    }

    /**
     * 处理档案提交（新增、修改、删除）
     *
     * @param frontSubmitDto 前端提交的数据
     * @return 处理结果
     * lqx
     */
    @Override
    public int handleRecordsSubmit(FrontSubmitDto frontSubmitDto) {
        System.out.println("frontSubmitDto = " + frontSubmitDto);
        int totalAffected = 0; // 总受影响记录数

        if (frontSubmitDto == null || frontSubmitDto.getAllUsersData() == null) {
            return totalAffected;
        }

        // 处理每个用户的数据
        for (UserDataDto userData : frontSubmitDto.getAllUsersData()) {
            String registrationId = userData.getRegistrationId();
            if (registrationId == null || registrationId.trim().isEmpty()) {
                continue;
            }

            // 1. 查询该报名ID下已有的所有有效档案
            List<Records> existingRecords = recordsMapper.selectRecordsByRegistrationId(registrationId);

            // 按文件类型分组，便于快速查找
            Map<String, Records> existingRecordsMap = existingRecords.stream()
                    .collect(Collectors.toMap(Records::getRecordType, record -> record));

            // 2. 处理当前提交的文件
            List<Records> recordsToAdd = new ArrayList<>();
            List<String> typesToDelete = new ArrayList<>();

            if (userData.getFileUnits() != null) {
                for (FileUnitDto fileUnit : userData.getFileUnits()) {
                    String fileType = fileUnit.getFileType();
                    String url = fileUnit.getUrl();

                    // 2.1 URL为空，说明用户未上传该文件
                    if (url == null || url.trim().isEmpty()) {
                        // 只有数据库中存在该类型的历史记录时，才需要逻辑删除
                        if (existingRecordsMap.containsKey(fileType)) {
                            typesToDelete.add(fileType);
                        }
                        continue;
                    }

                    // 2.2 提取文件名（从URL中截取）
                    String fileName = extractFileNameFromUrl(url);

                    // 2.3 检查是否存在同类型的记录
                    if (existingRecordsMap.containsKey(fileType)) {
                        Records existingRecord = existingRecordsMap.get(fileType);
                        String existingFileName = extractFileNameFromUrl(existingRecord.getUrl());

                        // 文件名不同，需要删除旧记录并新增新记录
                        if (!fileName.equals(existingFileName)) {
                            typesToDelete.add(fileType);

                            // 创建新记录
                            Records newRecord = createNewRecord(registrationId, fileUnit, userData);
                            recordsToAdd.add(newRecord);
                        }
                        // 文件名相同，不做操作
                    } else {
                        // 不存在同类型记录，直接新增
                        Records newRecord = createNewRecord(registrationId, fileUnit, userData);
                        recordsToAdd.add(newRecord);
                    }
                }
            }

            // 3. 执行删除操作
            if (!typesToDelete.isEmpty()) {
                int deletedCount = recordsMapper.logicDeleteByRegistrationIdAndTypes(
                        registrationId,
                        typesToDelete,
                        SecurityUtils.getUsername()
                );
                totalAffected += deletedCount;
            }

            // 4. 执行新增操作
            if (!recordsToAdd.isEmpty()) {
                int insertedCount = recordsMapper.batchInsert(recordsToAdd);
                totalAffected += insertedCount;
            }

            //5.设置档案缺失情况
            //5.1 提取已存在的档案类型（英文）
            Set<String> existingTypes = existingRecords.stream()
                    .map(Records::getRecordType)
                    .collect(Collectors.toSet());
            //5.2. 判断是否有档案（无论是否齐全）
            boolean hasAnyRecord = !existingRecords.isEmpty();
            //5.3 找出所有档案类型中缺失的类型
            List<String> missingChineseTypes = new ArrayList<>();
            for (Map.Entry<String, String> entry : RECORD_TYPE_MAP.entrySet()) {
                String englishType = entry.getKey();
                String chineseType = entry.getValue();
                if (!existingTypes.contains(englishType)) {
                    missingChineseTypes.add(chineseType);
                }
            }
            //5.4. 拼接缺失的中文名称（用“；”分隔）
            String recordMissing = String.join("；", missingChineseTypes);
            //5.5. 判定状态码
            String recordStatus;
            if (!hasAnyRecord) {
                // 无任何有效档案
                recordStatus = "2";
            } else if (missingChineseTypes.isEmpty()) {
                // 有档案且全部齐全
                recordStatus = "0";
            } else {
                // 有档案但不齐全
                recordStatus = "1";
            }
            //5.4设置该报名的档案缺失情况和档案状态
            Registration registration = new Registration();
            registration.setRegistrationId(registrationId);
            registration.setRecordMissing(recordMissing);
            registration.setRecordStatus(recordStatus);
            registrationMapper.updateRegistration(registration);

            //6.档案备注
            Remarks remarks = new Remarks();
            //设置外键id
            remarks.setForeignId(registrationId);
            //设置备注类型
            remarks.setRemarkType("7");
            //设置备注内容
            remarks.setRemarks(userData.getRemark());
            //新增备注
            remarksService.insertRemarks(remarks);
        }

        return totalAffected;
    }

    /**
     * 从URL中提取文件名
     */
    private String extractFileNameFromUrl(String url) {
        if (url == null || url.isEmpty()) {
            return "";
        }
        return url.substring(url.lastIndexOf("/") + 1);
    }

    /**
     * 创建新的档案记录
     */
    private Records createNewRecord(String registrationId, FileUnitDto fileUnit, UserDataDto userData) {
        Records record = new Records();
//        record.setRecordId(String.valueOf(new SnowflakeIdUtils(5, 8).nextId()));
        record.setRecordId(String.valueOf(snowflake.nextId()));
        System.out.println(record.getRecordId());
        record.setRegistrationId(registrationId);
        record.setUrl(fileUnit.getUrl());
        record.setRecordType(fileUnit.getFileType());
        record.setDelFlag("0"); // 0代表存在

        Date now = new Date();
        record.setCreateTime(now);
        record.setUpdateTime(now);
        record.setUpdateBy(SecurityUtils.getUsername());

        // 备用字段暂不赋值
        record.setIsTrace(null);
        record.setExampleOne(null);
        record.setExampleTwo(null);
        record.setExampleThree(null);

        // remark字段预留，暂不处理
        // record.setRemark(userData.getRemark());

        return record;
    }

    /**
     * 处理上传资料
     * lqx
     */
    @Override
    public RecordsUploadProcessDto recordsUploadProcess(RecordsUploadProcessVo vo) {
        // 1. 初始化结果对象（新增操作类型标记：新增/替换）
        RecordsUploadProcessDto resultDto = new RecordsUploadProcessDto();
        List<RecordsUploadProcessDto.RegistrationProcessDetail> details = new ArrayList<>();
        resultDto.setProcessDetails(details);

        // 2. 初始化统计数据
        int totalRegCount = vo.getRegistrationIds() != null ? vo.getRegistrationIds().length : 0;
        resultDto.setTotalRegistrationCount(totalRegCount);
        int successRegCount = 0;
        int failRegCount = 0;
        int totalFileCount = 0;
        int successFileCount = 0;
        int failFileCount = 0;
        int replaceFileCount = 0; // 新增：统计替换的文件数
        int addFileCount = 0;     // 新增：统计新增的文件数

        try {
            validateParams(vo);
            boolean isMultiUpload = vo.getRegistrationIds().length > 1;

            for (String registrationId : vo.getRegistrationIds()) {
                RecordsUploadProcessDto.RegistrationProcessDetail regDetail = new RecordsUploadProcessDto.RegistrationProcessDetail();
                regDetail.setRegistrationId(registrationId);
                regDetail.setFileDetails(new ArrayList<>());

                try {
                    // 3. 查询报名信息（姓名+身份证号）
                    Registration registration = registrationMapper.selectRegistrationByRegistrationId(registrationId);
                    if (registration == null) {
                        throw new RuntimeException("未找到报名ID对应的信息");
                    }
                    //通过id查询学员信息
                    Students students = studentsMapper.selectStudentsByStudentId(registration.getStudentId());
                    String name = students.getStudentName();
                    String idCard = students.getIdNumber();
                    regDetail.setName(name);
                    regDetail.setIdCard(idCard);

                    // 4. 构建目标文件夹路径
                    String targetFolderName = name + idCard;
                    String targetFolderPath = buildTargetFolderPath(vo.getFolderPath(), targetFolderName, isMultiUpload);
                    File targetFolder = new File(targetFolderPath);
                    if (!targetFolder.exists() || !targetFolder.isDirectory()) {
                        throw new RuntimeException("文件夹不存在：" + targetFolderPath);
                    }

                    // 5. 获取新上传的文件
                    File[] files = targetFolder.listFiles();
                    if (files == null || files.length == 0) {
                        regDetail.setSuccess(true);
                        regDetail.setFileCount(0);
                        regDetail.setMessage("文件夹无文件，处理成功（待审核）");
                        details.add(regDetail);
                        successRegCount++;
                        continue;
                    }
                    totalFileCount += files.length;
                    regDetail.setFileCount(files.length);

                    // 6. 根据上传方式处理
                    String uploadMethod = vo.getUploadMethod();

                    if ("0".equals(uploadMethod)) {
                        // 覆盖上传：仅处理文件，不查询历史（保持不变）
                        processFilesForPreview(files, regDetail, successFileCount, failFileCount, addFileCount, null);
                    } else if ("1".equals(uploadMethod)) {
                        // 补充上传：查询已有档案并匹配文件名
                        // 6.1 查询该报名下的所有已有档案
                        List<Records> existingRecords = recordsMapper.selectRecordsByRegistrationId(registrationId);
                        // 6.2 从文件路径中提取文件名，构建"文件名→档案记录"映射（核心逻辑）
                        Map<String, Records> existingFileMap = extractFileNameMap(existingRecords);
                        // 6.3 处理新文件，标记新增/替换
                        processFilesWithSupplementaryForPreview(files, regDetail, successFileCount, failFileCount,
                                addFileCount, replaceFileCount, existingFileMap);
                    }

                    // 7. 判断报名整体处理结果
                    boolean isRegSuccess = regDetail.getFileDetails().stream()
                            .allMatch(RecordsUploadProcessDto.FileDetail::isFileSuccess);
                    regDetail.setSuccess(isRegSuccess);
                    regDetail.setMessage(isRegSuccess ?
                            String.format("处理成功（待审核），新增%d个，替换%d个", addFileCount, replaceFileCount) :
                            "部分文件处理失败");
                    if (isRegSuccess) {
                        successRegCount++;
                    } else {
                        failRegCount++;
                    }

                } catch (Exception e) {
                    regDetail.setSuccess(false);
                    regDetail.setMessage("处理失败：" + e.getMessage());
                    failRegCount++;
                    log.error("处理报名ID:{}出错", registrationId, e);
                }

                details.add(regDetail);
            }

            // 8. 填充统计数据（包含新增/替换计数）
            resultDto.setSuccessRegistrationCount(successRegCount);
            resultDto.setFailRegistrationCount(failRegCount);
            resultDto.setTotalFileCount(totalFileCount);
            resultDto.setSuccessFileCount(successFileCount);
            resultDto.setFailFileCount(failFileCount);
            // 扩展统计：返回新增和替换的文件总数
            resultDto.setAddFileCount(addFileCount);       // 新增字段
            resultDto.setReplaceFileCount(replaceFileCount); // 新增字段

        } catch (Exception e) {
            resultDto.setErrorMessage("批量处理失败：" + e.getMessage());
            log.error("档案批量处理全局错误", e);
        }

        return resultDto;
    }

    /**
     * 参数校验（保持不变）
     */
    private void validateParams(RecordsUploadProcessVo vo) {
        if (vo.getRegistrationIds() == null || vo.getRegistrationIds().length == 0) {
            throw new IllegalArgumentException("请选择报名数据（registrationIds不能为空）");
        }
        if (StringUtils.isEmpty(vo.getFolderPath())) {
            throw new IllegalArgumentException("文件夹路径（folderPath）不能为空");
        }
        if (!"0".equals(vo.getUploadMethod()) && !"1".equals(vo.getUploadMethod())) {
            throw new IllegalArgumentException("上传方式必须为0（覆盖）或1（补充）");
        }
    }

    /**
     * 构建目标文件夹路径（保持不变）
     */
    private String buildTargetFolderPath(String baseFolderPath, String targetFolderName, boolean isMultiUpload) {
        if (isMultiUpload) {
            return baseFolderPath + File.separator + targetFolderName;
        } else {
            File baseFolder = new File(baseFolderPath);
            if (!baseFolder.getName().equals(targetFolderName)) {
                throw new RuntimeException("单人上传文件夹名必须为：" + targetFolderName);
            }
            return baseFolderPath;
        }
    }

    /**
     * 处理文件（覆盖上传模式，仅预览）
     * 移除数据库相关逻辑，仅处理文件类型校验和URL生成
     */
    private void processFilesForPreview(File[] files,
                                        RecordsUploadProcessDto.RegistrationProcessDetail regDetail,
                                        int successFileCount, int failFileCount) {
        for (File file : files) {
            if (file.isFile()) {
                processSingleFileForPreview(file, regDetail, successFileCount, failFileCount);
            }
        }
    }

    /**
     * 处理文件（补充上传模式，仅预览）
     * 移除历史记录查询和数据库更新逻辑，仅处理文件本身
     */
    private void processFilesWithSupplementaryForPreview(File[] files,
                                                         RecordsUploadProcessDto.RegistrationProcessDetail regDetail,
                                                         int successFileCount, int failFileCount) {
        for (File file : files) {
            if (file.isFile()) {
                // 仅处理文件预览，不匹配历史记录（数据库操作延后到审核后）
                processSingleFileForPreview(file, regDetail, successFileCount, failFileCount);
            }
        }
    }

    /**
     * 处理单个文件（仅预览，不涉及数据库记录创建）
     */
    private void processSingleFileForPreview(File file,
                                             RecordsUploadProcessDto.RegistrationProcessDetail regDetail,
                                             int successFileCount, int failFileCount) {
        RecordsUploadProcessDto.FileDetail fileDetail = new RecordsUploadProcessDto.FileDetail();
        fileDetail.setFileName(file.getName());
        fileDetail.setFilePath(file.getAbsolutePath());

        // 校验文件类型（仅允许图片）
        String fileType = getImageType(file);
        fileDetail.setFileType(fileType);

        if (!isImageTypeValid(fileType)) {
            // 非图片类型：标记失败
            fileDetail.setFileSuccess(false);
            fileDetail.setFileMessage("文件类型不支持（仅图片）");
            regDetail.getFileDetails().add(fileDetail);
            failFileCount++;
            return;
        }

        // 图片类型：生成访问URL（不创建数据库记录）
        try {
            String fileUrl = generateFileUrl(file.getAbsolutePath());
            fileDetail.setFileUrl(fileUrl);

            fileDetail.setFileSuccess(true);
            fileDetail.setFileMessage("图片处理成功（待审核）");
            successFileCount++;
        } catch (Exception e) {
            fileDetail.setFileSuccess(false);
            fileDetail.setFileMessage("处理失败：" + e.getMessage());
            failFileCount++;
        }

        regDetail.getFileDetails().add(fileDetail);
    }

    /**
     * 生成前端可访问的图片URL（保持不变）
     */
    private String generateFileUrl(String absoluteFilePath) {
        try {
//            String relativePath = absoluteFilePath.replace(rootUploadPath + File.separator, "");
//            relativePath = relativePath.replace(File.separator, "/");
//            String encodedPath = URLEncoder.encode(relativePath, StandardCharsets.UTF_8.name());
//            return serverUrl + "/api/files/image?relativePath=" + encodedPath;
            return null;
        } catch (Exception e) {
            log.error("生成文件URL失败", e);
            return null;
        }
    }

    /**
     * 判断是否为有效图片类型（保持不变）
     */
    private boolean isImageTypeValid(String fileType) {
        return fileType.startsWith("JPEG") || fileType.startsWith("PNG") ||
                fileType.startsWith("GIF") || fileType.startsWith("BMP") ||
                fileType.startsWith("其他图片");
    }

    /**
     * 获取图片类型（保持不变）
     */
    private String getImageType(File file) {
        try {
            String mimeType = Files.probeContentType(Paths.get(file.getAbsolutePath()));
            if (mimeType == null) return "未知类型（非图片）";

            if (mimeType.startsWith("image/")) {
                switch (mimeType) {
                    case "image/jpeg":
                        return "JPEG图片";
                    case "image/png":
                        return "PNG图片";
                    case "image/gif":
                        return "GIF图片";
                    case "image/bmp":
                        return "BMP图片";
                    default:
                        return "其他图片类型";
                }
            } else {
                return "非图片类型（" + mimeType + "）";
            }
        } catch (Exception e) {
            log.warn("获取文件类型失败：{}", file.getName(), e);
            return "文件类型校验失败（非图片）";
        }
    }

    /**
     * 从已有档案的路径中提取文件名，构建映射表
     * 解决：档案表没有文件名字段，通过路径字符串处理获取文件名
     */
    private Map<String, Records> extractFileNameMap(List<Records> existingRecords) {
        Map<String, Records> fileMap = new HashMap<>();
        if (existingRecords == null || existingRecords.isEmpty()) {
            return fileMap;
        }
        for (Records record : existingRecords) {
            String filePath = record.getUrl(); // 数据库中存储的文件路径
            if (StringUtils.isEmpty(filePath)) {
                continue;
            }
            // 从路径中提取文件名（兼容Windows和Linux路径分隔符）
            String fileName = new File(filePath).getName();
            fileMap.put(fileName, record);
        }
        return fileMap;
    }

    /**
     * 处理补充上传的文件（查询已有档案，标记新增/替换）
     */
    private void processFilesWithSupplementaryForPreview(File[] files,
                                                         RecordsUploadProcessDto.RegistrationProcessDetail regDetail,
                                                         int successFileCount, int failFileCount,
                                                         int addFileCount, int replaceFileCount,
                                                         Map<String, Records> existingFileMap) {
        for (File file : files) {
            if (file.isFile()) {
                String fileName = file.getName(); // 新文件的文件名
                // 判断是否与已有档案重名
                boolean isReplace = existingFileMap.containsKey(fileName);
                // 处理单个文件，并标记操作类型（新增/替换）
                processSingleFileForPreview(file, regDetail, successFileCount, failFileCount,
                        isReplace ? "替换" : "新增");
                // 更新统计
                if (isReplace) {
                    replaceFileCount++;
                } else {
                    addFileCount++;
                }
            }
        }
    }

    /**
     * 处理单个文件（补充：新增操作类型标记）
     */
    private void processSingleFileForPreview(File file,
                                             RecordsUploadProcessDto.RegistrationProcessDetail regDetail,
                                             int successFileCount, int failFileCount,
                                             String operationType) { // 新增：操作类型（新增/替换）
        RecordsUploadProcessDto.FileDetail fileDetail = new RecordsUploadProcessDto.FileDetail();
        fileDetail.setFileName(file.getName());
        fileDetail.setFilePath(file.getAbsolutePath());
        fileDetail.setOperationType(operationType); // 记录操作类型

        // 图片类型校验（保持不变）
        String fileType = getImageType(file);
        fileDetail.setFileType(fileType);

        if (!isImageTypeValid(fileType)) {
            fileDetail.setFileSuccess(false);
            fileDetail.setFileMessage("文件类型不支持（仅图片）");
            regDetail.getFileDetails().add(fileDetail);
            failFileCount++;
            return;
        }

        // 生成URL（保持不变）
        try {
            String fileUrl = generateFileUrl(file.getAbsolutePath());
            fileDetail.setFileUrl(fileUrl);
            fileDetail.setFileSuccess(true);
            fileDetail.setFileMessage(String.format("%s成功（待审核）", operationType));
            successFileCount++;
        } catch (Exception e) {
            fileDetail.setFileSuccess(false);
            fileDetail.setFileMessage(String.format("%s失败：%s", operationType, e.getMessage()));
            failFileCount++;
        }

        regDetail.getFileDetails().add(fileDetail);
    }

    /**
     * 处理覆盖上传的文件（无需查询历史，统一标记为"新增"）
     */
    private void processFilesForPreview(File[] files,
                                        RecordsUploadProcessDto.RegistrationProcessDetail regDetail,
                                        int successFileCount, int failFileCount,
                                        int addFileCount, Map<String, Records> existingFileMap) {
        for (File file : files) {
            if (file.isFile()) {
                processSingleFileForPreview(file, regDetail, successFileCount, failFileCount, "新增");
                addFileCount++;
            }
        }
    }


}
